package com.zzz.demo.utils;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashMap;
import java.util.Map;

/**
 * @author ZZZ
 * @version 1.0
 * @date 2018/12/4 004
 */
public class ShellUtil {
    
    /**
     * Logger for this class
     */
    private static final Logger logger = LoggerFactory.getLogger(ShellUtil.class);


    public static final String CPU_MEM_SHELL = "top -b -n 1";
    public static final String FILES_SHELL = "df -h";
    public static final String[] COMMANDS = {CPU_MEM_SHELL, FILES_SHELL};
    public static final String LINE_SEPARATOR = System.getProperty("line.separator");
    public static final String DISK_SIZE = "size"; // 磁盘总空间
    public static final String DISK_USED = "used"; // 已使用空间
    public static final String DISK_AVAILABLE = "available"; // 可用空间
    private static Session session;

    /**
     * 连接到指定的HOST
     *
     * @return isConnect
     * @throws JSchException JSchException
     */
    private static boolean connect(String user, String passwd, String host) {
        JSch jsch = new JSch();
        try {
            session = jsch.getSession(user, host, 22);
            session.setPassword(passwd);

            java.util.Properties config = new java.util.Properties();
            config.put("StrictHostKeyChecking", "no");
            session.setConfig(config);

            session.connect();
        } catch (JSchException e) {
            e.printStackTrace();
            System.out.println("connect error !");
            return false;
        }
        return true;
    }

    /**
     * 远程连接Linux 服务器 执行相关的命令
     *
     * @param commands 执行的脚本
     * @param user     远程连接的用户名
     * @param passwd   远程连接的密码
     * @param host     远程连接的主机IP
     * @return 最终命令返回信息
     */
    public static Map<String, String> runDistanceShell(String[] commands, String user, String passwd, String host) {
        if (!connect(user, passwd, host)) {
            return null;
        }
        Map<String, String> map = new HashMap<>();
        StringBuilder stringBuffer;

        BufferedReader reader = null;
        Channel channel = null;
        try {
            for (String command : commands) {
                stringBuffer = new StringBuilder();
                channel = session.openChannel("exec");
                ((ChannelExec) channel).setCommand(command);

                channel.setInputStream(null);
                ((ChannelExec) channel).setErrStream(System.err);

                channel.connect();
                InputStream in = channel.getInputStream();
                reader = new BufferedReader(new InputStreamReader(in));
                String buf;
                while ((buf = reader.readLine()) != null) {

                    //舍弃PID 进程信息
                    if (buf.contains("PID")) {
                        break;
                    }
                    stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                }
                //每个命令存储自己返回数据-用于后续对返回数据进行处理
                map.put(command, stringBuffer.toString());
            }
        } catch (IOException | JSchException e) {
            e.printStackTrace();
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (channel != null) {
                channel.disconnect();
            }
            session.disconnect();
        }
        return map;
    }


    /**
     * 直接在本地执行 shell
     *
     * @param commands 执行的脚本
     * @return 执行结果信息
     */
    public static Map<String, String> runLocalShell(String[] commands) {
        Runtime runtime = Runtime.getRuntime();

        Map<String, String> map = new HashMap<>();
        StringBuilder stringBuffer;

        BufferedReader reader;
        Process process;
        for (String command : commands) {
            stringBuffer = new StringBuilder();
            try {
                process = runtime.exec(command);
                InputStream inputStream = process.getInputStream();
                reader = new BufferedReader(new InputStreamReader(inputStream));
                String buf;
                while ((buf = reader.readLine()) != null) {
                    //舍弃PID 进程信息
                    if (buf.contains("PID")) {
                        break;
                    }
                    stringBuffer.append(buf.trim()).append(LINE_SEPARATOR);
                }

            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
            //每个命令存储自己返回数据-用于后续对返回数据进行处理
            map.put(command, stringBuffer.toString());
        }
        return map;
    }


    /**
     * 处理 shell 返回的信息
     * <p>
     * 具体处理过程以服务器返回数据格式为准
     * 不同的Linux 版本返回信息格式不同
     *
     * @param result shell 返回的信息
     * @return 最终处理后的信息
     */
    public static String disposeResultMessage(Map<String, String> result) {
        StringBuilder buffer = new StringBuilder();
        for (String command : COMMANDS) {
            String commandResult = result.get(command);
            if (null == commandResult) continue;
            buffer.append(displayResultByType(command, commandResult));
        }
        return buffer.toString();
    }

    private static StringBuilder displayResultByType(String command, String commandResult) {
        StringBuilder buffer = new StringBuilder();
        if (command.equals(CPU_MEM_SHELL)) {
            String[] strings = commandResult.split(LINE_SEPARATOR);
            //将返回结果按换行符分割
            for (String line : strings) {
                line = line.toUpperCase();//转大写处理

                //处理CPU Cpu(s): 10.8%us,  0.9%sy,  0.0%ni, 87.6%id,  0.7%wa,  0.0%hi,  0.0%si,  0.0%st
                if (line.startsWith("CPU(S):")) {
                    String cpuStr = "CPU 用户使用占有率:";
                    try {
                        cpuStr += line.split(":")[1].split(",")[0].replace("US", "");
                    } catch (Exception e) {
                        e.printStackTrace();
                        cpuStr += "计算过程出错";
                    }
                    buffer.append(cpuStr).append(LINE_SEPARATOR);

                    //处理内存 Mem:  66100704k total, 65323404k used,   777300k free,    89940k buffers
                } else if (line.startsWith("MEM")) {
                    String memStr = "内存使用情况:";
                    try {
                        memStr += line.split(":")[1]
                                .replace("TOTAL", "总计")
                                .replace("USED", "已使用")
                                .replace("FREE", "空闲")
                                .replace("BUFFERS", "缓存");

                    } catch (Exception e) {
                        e.printStackTrace();
                        memStr += "计算过程出错";
                        buffer.append(memStr).append(LINE_SEPARATOR);
                        continue;
                    }
                    buffer.append(memStr).append(LINE_SEPARATOR);

                }
            }
        } else if (command.equals(FILES_SHELL) || command.startsWith("df")) {
            //处理系统磁盘状态
            buffer.append("系统磁盘状态:");
            try {
                buffer.append(disposeFilesSystem(commandResult)).append(LINE_SEPARATOR);
            } catch (Exception e) {
                e.printStackTrace();
                buffer.append("计算过程出错").append(LINE_SEPARATOR);
            }
        }
        return buffer;
    }

    //处理系统磁盘状态

    /**
     * Filesystem            Size  Used Avail Use% Mounted on
     * /dev/sda3             442G  327G   93G  78% /
     * tmpfs                  32G     0   32G   0% /dev/shm
     * /dev/sda1             788M   60M  689M   8% /boot
     * /dev/md0              1.9T  483G  1.4T  26% /ezsonar
     *
     * @param commandResult 处理系统磁盘状态shell执行结果
     * @return 处理后的结果
     */
    private static String disposeFilesSystem(String commandResult) {
        BigDecimal size; // 总量
        BigDecimal used; // 使用量
        BigDecimal available; // 可用量
        Map<String, BigDecimal> decimalMap = calculateDiskSize(commandResult);
        size = decimalMap.get(DISK_SIZE);
        used = decimalMap.get(DISK_USED);
        available = decimalMap.get(DISK_AVAILABLE);
        return new StringBuilder().append("大小 ").append(size).append("G , 已使用").append(used).append("G ,空闲")
                .append(available).append("G").toString();
    }

    /**
     * @desc 计算每一行返回值，统计磁盘大小
     * @author ZZZ
     * @date 2018/12/5 005
     * @version 1.0
     */
    public static Map<String, BigDecimal> calculateDiskSize(String commandResult) {
        BigDecimal size = BigDecimal.ZERO; // 总量
        BigDecimal used = BigDecimal.ZERO; // 使用量
        BigDecimal available = BigDecimal.ZERO; // 可用量
        Map<String, BigDecimal> resultMap = new HashMap<>();
        String[] results = commandResult.split(LINE_SEPARATOR);
        for (int i = 0; i < results.length; i++) {
            if (i == 0) continue;
            int temp = 0;
            String strLine = results[i]; // 每一行的数据 like this @ /dev/sda3  442G  327G  93G  78% /
            for (String str : strLine.split("\\s+")) {
                // 第一列不要
                if (temp == 0) {
                    temp++;
                    continue;
                }
                if (!str.trim().isEmpty()) {
                    if (temp == 1) {
                        size = size.add(disposeUnit(str));
                        temp++;
                    } else if (temp == 2) {
                        used = used.add(disposeUnit(str));
                        temp++;
                    } else if (temp == 3) {
                        available = available.add(disposeUnit(str));
                        // 后面的不要了
                        break;
                    }
                }
            }
        }
        resultMap.put(DISK_SIZE, size);
        resultMap.put(DISK_USED, used);
        resultMap.put(DISK_AVAILABLE, available);
        return resultMap;
    }

    /**
     * 处理单位转换
     * K/KB/M/T 最终转换为G 处理
     *
     * @param str 带单位的数据字符串
     * @return 以G 为单位处理后的数值
     */
    private static BigDecimal disposeUnit(String str) {
        str = str.toUpperCase();
        String lastIndex = str.substring(str.length() - 1);
        String num = str.substring(0, str.length() - 1);
        BigDecimal size = new BigDecimal(num);
        BigDecimal multiplicand = new BigDecimal(1024);
        if (lastIndex.equals("G")) {
            return size;
        } else if (lastIndex.equals("T")) {
            return size.multiply(multiplicand);
        } else if (lastIndex.equals("M")) {
            return size.divide(multiplicand, 2, RoundingMode.HALF_UP);
        } else if (lastIndex.equals("K") || lastIndex.equals("KB")) {
            return size.divide(multiplicand.pow(2), 2, RoundingMode.HALF_UP);
        }
        return BigDecimal.ZERO;
    }

    /**
     * @desc 查询CPU使用率，内存使用情况和磁盘使用情况
     * @author ZZZ
     * @date 2018/12/4 004
     * @version 1.0
     */
    public static void main(String[] args) {
        Map<String, String> result = runDistanceShell(COMMANDS, "root", "0p-0p-0p-", "192.168.10.171");
        logger.debug(disposeResultMessage(result));
    }

}